Skip to content

task: halui's pins in task - #4832

Draft
rene-dev wants to merge 27 commits into
LinuxCNC:masterfrom
rene-dev:task-hal
Draft

rene-dev wants to merge 27 commits into
LinuxCNC:masterfrom
rene-dev:task-hal

Conversation

@rene-dev

Copy link
Copy Markdown
Member

This is the first step towards removing halui: task exports the halui pins
that motion and iocontrol don't already have, as a HAL component task
with halui's pin names under task.. Overrides, MDI commands, jogging and
joint/axis selection follow in later PRs; halui is untouched here and keeps
working.

The first three commits are groundwork with no change in behaviour, and the
first one is what shows that.

Commits

  1. tests: record what the task planner does with every command
    tests/task-planner brings task into each situation the planner tells
    apart (E-stop, off, Manual, MDI idle and running, Auto idle, reading,
    waiting, paused) and sends it every command emcTaskPlan() handles, one
    at a time. From task's own debug output it records whether the planner
    issued the command, queued it, refused it or handled it itself, and what
    situation the command left task in. expected is today's behaviour, so a
    change to the planner either leaves the table alone or shows up as a diff
    of it. The commands come from test_task_probe, a small NML client built
    for run-in-place only (not installed; the test skips without it). About
    a minute. It is scaffolding for the refactoring of task that follows
    (this PR and the modeless task); once that is done, the test and
    test_task_probe are removed again.
  2. task: hand emcTaskPlan() the new command
    The main loop decides whether there is a new command and passes it, or
    NULL; the planner no longer reads the NML buffer itself. This is what
    lets a command reach the planner another way. Table unchanged.
  3. task: one list of immediate commands for the planner tables
    The eight tables repeated the commands each passes straight to
    emcTaskIssueCommand(). isImmediate() says this once, by state, mode
    and interpreter state; each table keeps only what is special to it and
    its refusal message. 256 lines shorter. Table unchanged; letting spindle
    orient through in Manual, as an example of a slip, fails the test.
  4. task: export halui's status pins that motion and iocontrol lack
    The task component and its status pins (table below). task.tool.diameter
    reads the loaded tool's entry from the status, as halui does since
    7412d9d, so task's pins need no tool table access. Updated once per
    task cycle from task's own status, so current in the same cycle where
    halui's lag by its poll. The component is created before inihal is
    ready, because the linuxcnc script runs the HAL files as soon as it is:
    HAL files can connect task.* pins, as they can halui's.
    tests/task-hal-pins connects some in a HAL file and compares every one
    with halui's pin in Manual, teleop, MDI with offsets and tools, with
    overrides, and while a program runs and is paused.
  5. task: halui's command pins, as task-internal commands
    The command inputs. Like halui's they act on the rising edge and send
    the same commands, but not through NML: emcTaskQueueInternalCommand()
    queues them and the main loop hands one to emcTaskPlan() on each cycle
    without a new NML command. They leave the echo serial number alone, a
    refused one is reported on the error channel only, and none of them
    changes the status of the UI's last command. tests/task-hal-inputs
    pulses each pin without halui and checks both.
  6. task: the halui pins whose iocontrol counterpart differs
    task.estop.is-activated (iocontrol's is inverted), task.estop.activate
    (iocontrol's is a level, not an edge) and task.tool.number (iocontrol's
    is signed). With these, a configuration can be moved off halui's covered
    pins by renaming alone.

Every commit builds and passes the task, halui, abort, linuxcncrsh,
mdi-queue and toolchanger tests on its own.

Difference from halui

No task.mode.manual / .auto / .mdi: task's mode is to follow what
task runs rather than be set (the modeless task work). task.program.run
switches to Auto first, as halui does.

Found along the way

#4831: after a tool command in Manual or MDI, task's wait flag stays set and
MDI commands are queued instead of issued until a program runs. The planner
test clears the flag before each situation so that no cell depends on
earlier probes; the behaviour itself is left as it is here.

halui's pins and where they go

✅ the same signal already exists elsewhere · ◐ partly, or with different
semantics · ❌ nothing. The last column is the task.* pin from this PR, or
where the rest is planned to go.

Status outputs

halui pin type alternative task pin
halui.machine.is-on bit motion.motion-enabled ✅ —
halui.machine.units-per-mm float — (INI constant) ❌ task.machine.units-per-mm
halui.estop.is-activated bit iocontrol.0.user-enable-out (inverted) ◐ task.estop.is-activated
halui.mode.is-manual bit — ❌ task.mode.is-manual
halui.mode.is-auto bit — ❌ task.mode.is-auto
halui.mode.is-mdi bit — ❌ task.mode.is-mdi
halui.mode.is-teleop bit motion.teleop-mode ✅ —
halui.mode.is-joint bit motion.teleop-mode/motion.coord-mode both false ◐ task.mode.is-joint
halui.mist.is-on bit iocontrol.0.coolant-mist ✅ —
halui.flood.is-on bit iocontrol.0.coolant-flood ✅ —
halui.program.is-idle bit — ❌ task.program.is-idle
halui.program.is-running bit — ❌ task.program.is-running
halui.program.is-paused bit — ❌ task.program.is-paused
halui.program.optional-stop.is-on bit — ❌ task.program.optional-stop.is-on
halui.program.block-delete.is-on bit — ❌ task.program.block-delete.is-on
halui.halui-mdi-is-running bit — (halui-internal state) ❌ later (task), with the MDI commands
halui.max-velocity.value float — ❌ task.max-velocity.value
halui.feed-override.value float — ❌ task.feed-override.value
halui.rapid-override.value float — ❌ task.rapid-override.value
halui.spindle.S.is-on bit spindle.S.on ✅ —
halui.spindle.S.runs-forward bit spindle.S.forward ✅ —
halui.spindle.S.runs-backward bit spindle.S.reverse ✅ —
halui.spindle.S.brake-is-on bit spindle.S.brake ✅ —
halui.spindle.S.override.value float — ❌ task.spindle.S.override.value
halui.joint.N.is-homed bit joint.N.homed ✅ —
halui.joint.N.has-fault bit joint.N.faulted ✅ —
halui.joint.N.on-hard-min-limit bit joint.N.neg-hard-limit ✅ —
halui.joint.N.on-hard-max-limit bit joint.N.pos-hard-limit ✅ —
halui.joint.N.on-soft-min-limit bit motion.on-soft-limit (global only) ◐ task.joint.N.on-soft-min-limit
halui.joint.N.on-soft-max-limit bit motion.on-soft-limit (global only) ◐ task.joint.N.on-soft-max-limit
halui.joint.N.override-limits bit — ❌ task.joint.N.override-limits
halui.joint.N.is-selected bit — (halui selection state) ❌ later (selection)
halui.joint.selected u32 — (halui selection state) ❌ later (selection)
halui.joint.selected.{is-homed,has-fault,on-*-limit,override-limits} bit — (mux of the above by selection) ❌ later (selection)
halui.axis.L.is-selected bit — (halui selection state) ❌ later (selection)
halui.axis.selected u32 — (halui selection state) ❌ later (selection)
halui.axis.L.pos-commanded float axis.L.pos-cmd ✅ —
halui.axis.L.pos-feedback float — (only joint-space joint.N.pos-fb) ◐ task.axis.L.pos-feedback
halui.axis.L.pos-relative float — (needs G5x/G92/G68/tool offsets) ❌ task.axis.L.pos-relative
halui.tool.number u32 iocontrol.0.tool-number (s32) ◐ task.tool.number
halui.tool.length_offset.{x..w} float motion.tooloffset.{x..w} ✅ —
halui.tool.diameter float — ❌ task.tool.diameter

Command inputs

halui pin type alternative task pin
halui.machine.on / .off bit — ❌ task.machine.on / .off
halui.estop.activate bit iocontrol.0.emc-enable-in low (a level that holds E-stop, not an edge) ◐ task.estop.activate
halui.estop.reset bit — ❌ task.estop.reset
halui.mode.manual / .auto / .mdi bit — ❌ none: task's mode is to follow what task runs (task-modeless)
halui.mode.teleop / .joint bit — ❌ task.mode.teleop / .joint
halui.mist.on / .off bit — ❌ task.mist.on / .off
halui.flood.on / .off bit — ❌ task.flood.on / .off
halui.program.run bit — ❌ task.program.run
halui.program.pause / .resume bit motion.feed-hold (needs M53) / motion.feed-inhibit — motion-level hold, not a task pause ◐ task.program.pause / .resume
halui.program.step bit — ❌ task.program.step
halui.program.stop bit — ❌ task.program.stop
halui.abort bit — (motion.jog-stop only stops jogs) ❌ task.abort
halui.program.optional-stop.on / .off bit — ❌ task.program.optional-stop.on / .off
halui.program.block-delete.on / .off bit — ❌ task.program.block-delete.on / .off
halui.home-all bit — ❌ task.home-all (only with [JOINT_0]HOME_SEQUENCE, like halui)
halui.joint.N.home / .unhome bit — ❌ task.joint.N.home / .unhome
halui.joint.selected.home / .unhome bit — ❌ later (selection)
halui.mdi-command-NN bit — ❌ later (task)
halui.max-velocity.{counts,count-enable,direct-value,scale,increase,decrease} s32/bit/float ini.traj_max_velocity (changes the limit, not the runtime value) ◐ later (task)
halui.feed-override.{counts,count-enable,direct-value,scale,increase,decrease,reset} s32/bit/float motion.adaptive-feed (scales feed, but invisible to GUIs, not an override) ◐ later (task)
halui.rapid-override.{counts,count-enable,direct-value,scale,increase,decrease,reset} s32/bit/float — ❌ later (task)
halui.spindle.S.override.{counts,count-enable,direct-value,scale,increase,decrease,reset} s32/bit/float — ❌ later (task)
halui.spindle.S.start / .stop bit — (spindle.S.inhibit can only block) ❌ task.spindle.S.start / .stop
halui.spindle.S.forward / .reverse bit — ❌ task.spindle.S.forward / .reverse
halui.spindle.S.increase / .decrease bit — ❌ task.spindle.S.increase / .decrease
halui.spindle.S.brake-on / .brake-off bit — ❌ task.spindle.S.brake-on / .brake-off
halui.joint.N.select bit — (halui selection state) ❌ later (selection)
halui.axis.L.select bit — (halui selection state) ❌ later (selection)
halui.joint.N.plus / .minus bit — (continuous jog) ❌ later (motion)
halui.joint.N.analog float — (velocity jog) ❌ later (motion)
halui.joint.N.increment + .increment-plus / .increment-minus float/bit joint.N.jog-counts + jog-scale + jog-enable (wheel jog; a pulse per press ≈ increment) ◐ later (motion)
halui.joint.selected.{plus,minus,increment,increment-plus,increment-minus} bit/float — ❌ later (selection)
halui.joint.jog-speed / .jog-deadband float — (config for the above) ❌ later (motion)
halui.axis.L.plus / .minus bit — ❌ later (motion)
halui.axis.L.analog float — ❌ later (motion)
halui.axis.L.increment + .increment-plus / .increment-minus float/bit axis.L.jog-counts + jog-scale + jog-enable ◐ later (motion)
halui.axis.selected.{plus,minus,increment,increment-plus,increment-minus} bit/float — ❌ later (selection)
halui.axis.jog-speed / .jog-deadband float — ❌ later (motion)

tests/task-planner brings task into each situation its planner tells
apart (E-stop, off, Manual, MDI idle and running, Auto idle, reading,
waiting and paused) and sends it every command emcTaskPlan() handles,
one at a time, plus one it has no case for. From task's own debug output
it records, for each, whether the planner issued the command, queued it
for later, refused it or handled it itself, and what situation the
command left task in. The table is compared with tests/task-planner/
expected, which is the behaviour of today's planner.

A change to the planner that is not meant to change behaviour leaves the
table as it is; one that is shows up as a diff of it.

The commands come from test_task_probe, a small NML client that sends
any of them with arguments that change as little as possible. It is
built for run-in-place only and not installed; the test skips without
it.
emcTaskPlan() found its command itself: it compared emcCommand's serial
number with the echoed one to tell a new command from none, and
allow_while_idle_type() read the command's type from the NML buffer once
more. Have the main loop make that decision and pass the new command,
or NULL, and use only that inside the planner.

This is what lets a command reach the planner by another way than the
NML buffer. No change in behaviour: tests/task-planner is unchanged.
The planner's tables repeated the commands each passes straight to
emcTaskIssueCommand(): 22 accepted in any state, three more only while
the machine is off, twelve once it is on, the spindle commands unless a
program is reading or waiting, the program and I/O commands unless one
runs, and so on. isImmediate() now says this once, by the state, mode
and interpreter state task is in, and each table keeps only what is
special to it and its own refusal. allow_while_idle_type() is part of
it now, and the three tool commands share queueToolCommand().

No change in behaviour: tests/task-planner is unchanged, and fails if
spindle orient is let through in Manual, as an example of a slip.
Task gets a HAL component, "task", with the status pins of halui that
have no equivalent elsewhere: the task mode and whether motion is in
joint mode, the interpreter state, optional stop and block delete, the
override and max-velocity values, the soft limits and override-limits
of each joint, each axis' Cartesian feedback and relative (DRO)
position, the tool diameter and units-per-mm. Their names are halui's
under "task." instead of "halui.".

They are updated once per task cycle from task's own status, so they
are current in the same cycle, where halui's lag by its poll.

The component is created before inihal is ready, so that the HAL files,
which the linuxcnc script runs as soon as inihal is, can connect its
pins, as they can halui's. The axes and spindles are therefore read from
the INI file, the way task sets motion up with them.

tests/task-hal-pins connects some of the pins in a HAL file, and
compares every one of them with halui's pin in manual, teleop, MDI with
offsets and tools, with overrides, and while a program runs and is
paused.
Task exports halui's command input pins: machine on/off, E-stop reset,
teleop/joint mode, mist and flood, program run/pause/resume/step/stop,
abort, optional stop and block delete, home-all (with
[JOINT_0]HOME_SEQUENCE, like halui), home and unhome of each joint, and
start/stop/forward/reverse/increase/decrease/brake of each spindle. Like
halui's they act on the rising edge, spindle increase and decrease also
on the falling one, and send the same commands.

halui's mode.manual, .auto and .mdi pins are left out: task's modes are
to follow what task runs rather than be set. program.run switches to
Auto first, as halui does.

The commands do not go through NML. emcTaskQueueInternalCommand() queues
them, and the main loop hands one to emcTaskPlan() on each cycle without
a new NML command. They leave the echo serial number alone, and a
refused one is reported on the error channel only: it does not turn the
status of the UI's last command into ERROR, nor does a successful one
clear that command's error.

tests/task-hal-inputs pulses each pin, without halui, and checks both;
it also sets one of the pins from a HAL file.
Three halui pins have a counterpart in iocontrol that is not quite the
same signal, so a configuration could not just be renamed to it:

- task.estop.is-activated: iocontrol.0.user-enable-out is its inverse.
- task.estop.activate: iocontrol.0.emc-enable-in is a level that holds
  the machine in E-stop; this is an edge that puts it there once.
- task.tool.number: iocontrol.0.tool-number is signed, halui's unsigned.

With these, each halui pin that motion, iocontrol or task now covers has
exactly one pin to be renamed to.
@grandixximo

Copy link
Copy Markdown
Contributor
  • tests/task-planner/test.sh:4: without test_task_probe it exits 0, then checkresult finds no probes and fails, so the package jobs fail. An executable skip file is what runtests uses for this: it runs the test when the file exits 0, so #!/bin/sh plus command -v test_task_probe >/dev/null would do.
  • tests/task-planner/test-ui.py:209: time.sleep(0.05) then reads the situation, 711 times. Under -j load a state change after 50 ms records - and the table differs. Wait on the probe-end message plus a settled status instead? That should also cut most of the minute.
  • tests/task-hal-inputs/test-ui.py:51: pulse() holds the pin high for 50 ms. Task sees an edge only if one of its cycles falls inside that window, so under -j load a pulse can be missed and press() times out. Hold it until cond() is true, then drop it? And line 120: time.sleep(0.2) before checking that the refused program.step left the status alone; waiting for the refusal on the error channel would prove task has handled it first.
  • tests/task-hal-pins and tests/task-hal-inputs: the two .ini files differ only in HALUI, the HAL file and HOME_SEQUENCE. Could they be one test, inputs first without halui, then the pins with it? Bertho raised the test count on task: an E-stop reset leaves a machine that is on alone #4801 (264 in 2.9, 360 on master).
  • emctaskmain.cc:3365: an internal command leaves the echo serial alone, but status follows the global state. With halui, its command bumps the serial and a GUI's wait_complete() returns; here a GUI waiting on its own command sees its serial with EXEC while a HAL-started program runs. Does a GUI then time out?
  • taskhal.cc:490: estop.activate is an edge, queued behind other internal commands and behind any NML command that cycle. Same as halui, but worth saying in the docs that it is not a safety input, so nobody "renames" iocontrol.0.emc-enable-in to it.
  • The table probes 79 commands; EMC_TOOL_PREPARE, EMC_SYSTEM_CMD, EMC_TRAJ_LINEAR_MOVE and EMC_JOINT_ACTIVATE are never sent, and there is no E-stop-in-MDI or MDI-paused situation. If it is to guard the modeless rework, add those?
  • Textual overlap with task: report the serial of a command that failed #4817 (failed serial) around emctaskmain.cc:3360; and modeless task, and jog-while-paused #4700 (modeless) rewrites the same main loop.

EMC_JOG_ABS, EMC_JOINT_HALT, EMC_JOINT_SET_FERROR, EMC_JOINT_SET_MIN_FERROR,
EMC_JOINT_SET_HOMING_PARAMS, EMC_TRAJ_SET_VELOCITY and
EMC_TRAJ_SET_ACCELERATION, with their classes, task's handling of them and
their rows in the planner table. emcJogAbs() had no other caller.
… of checkInterpList()

checkInterpList() lost its limit checks long ago and always returned 0; it
now only shows the operator errors of the lines it drops. task read
[TASK]MDI_QUEUED_COMMANDS and never used it.
42 file-level pointers each held the cast for one case. Those used once
are folded into the call; the others are declared in their case.
emcTaskCheckPreconditions() and emcTaskCheckPostconditions() become
commandWaits(), and the STEPPING_CHECK macro becomes steppingHolds(). The
table says what the two switches said, command for command.
emcTaskPlan() works out the situation once, then a command is handled by
the planner itself (planSpecial()), passed straight through
(isImmediate()) or refused (refuse()). The planner table is unchanged.
With EMC_JOG_ABS and emcJogAbs() gone the handler had no caller. In teleop
it was not absolute either: axis_jog_abs() added the target to the current
position.
test.sh exited 0 without the probe and checkresult then failed for lack of
probes, in every package build. A skip file is what runtests has for this.
The loop variable shellcheck flagged as unused (SC2034) is now _.
Axes can be jogged (keyboard, AXIS, halui, linuxcncrsh, wheel) while a
program or MDI command is paused, M0/M1 included, once the pause has
stopped the motion. Joints cannot.

Motion keeps the paused program position and adds a per-axis pause
offset on top of it, as the external offsets are added (axis_pause_*()
in axis.c), within the soft limits. The queued moves and the interpreter
are untouched. On resume or step, do_pause_resume() (control.c):

- puts the spindles back as they were at the pause (state, direction,
  speed, CSS) and waits for them to be at speed;
- returns the axes: the ones not in [TRAJ]PAUSE_RETURN_LAST (default Z)
  together in a straight line, then those, at the axis limits, and sets
  the offsets to exactly zero;
- then resumes or steps.

Task restores mist and flood. Pausing during the return stops it there.
An abort keeps the machine where it was jogged to: the planner takes the
offsets into its position. Reverse run is refused while jogged away.

Status: pause_offset, pause_jog_ok and pause_returning in EMC_MOTION_STAT
and Python. Task accepts axis jogs while paused (planSpecial()), halui
and linuxcncrsh send them, AXIS enables its jog and spindle controls (not
homing) and does not ask for Manual mode while paused.

This is the work from LinuxCNC#4700, for a task that still has modes:

- the mode stays Auto or MDI during the pause; nothing switches it;
- in coordinated mode without a pause (MDI mode, idle) a jog still does
  nothing and reports nothing;
- the planner table changes in one cell: EMC_JOG_STOP is issued while
  Auto is paused;
- no absolute jog, which this branch has removed.

Tests: new tests/jog-while-paused; motion-logger expectations gain the
SET_PAUSE_RETURN_LAST startup command.
Manual, MDI and Auto are no longer modes a user interface switches
between. Task tracks what it runs (idle, a program, MDI) and reports the
mode from that: Auto while a program runs or is paused, MDI while MDI
commands run, Manual otherwise.

- While idle task accepts jogs, homing, MDI commands and program runs.
  Starting a run checks homing, an open program and that no jog
  (including a wheel jog) is active, switches motion to coordinated mode
  and re-syncs the interpreter; nothing leaves interp_list until motion
  is in coordinated mode. When the run ends motion goes back to the joint
  or world mode it had before, so wheel jogs work whenever nothing runs.
- The planner chooses its command table by what runs: idle (the old
  Manual and Auto-idle tables merged), program (unchanged), MDI running
  (jogs and joint/world switching refused).
- EMC_TASK_SET_MODE is accepted in any state and does nothing.
- halui: halui.mode.manual, .mdi and .auto do nothing, the is-* pins show
  the derived mode, MDI commands go straight to task.

User interfaces that switch pages on the mode keep working through a
per-UI view mode: Python mode(), Tcl emc_mode and linuxcncrsh set mode
(per connection) record the page asked for, and task_mode / get mode
report it while task is idle. AXIS loses its "coordinated while Manual,
force teleop" kick and the dead tab-raise code.

Behaviour changes, documented in updating-linuxcnc: switching to Manual
no longer aborts a running MDI command; a run started from Manual runs
the program; a run with no program open is refused; the parameter file
is saved at the start of every MDI command from idle.

Tests: new tests/task-modeless; halui/mdi rewritten for the new
semantics; g28.2/invalid-pword waits for motion to leave coordinated
mode; motion-logger, M99, interp_initcode and linuxcncrsh expectations
updated for the mode switches that moved (COORD at run start, FREE or
TELEOP at run end, no abort from a mode change).
mode() sends nothing to task any more; it sets the page the user
interface shows. The wait_complete() after it waited on whatever command
came before, and while a program runs or is paused task does not report
DONE, so each one sat out its timeout: AXIS hung for 5 s on a spindle
button while paused (ensure_mode()).

Remove the wait after every mode() call in the user interfaces, their
libraries and the sample configs: AXIS, gmoccapy, gscreen and the
silverdragon skin, touchy, pyui, GStat, the gladevcp and qtvcp actions,
the gladevcp offset page and probe panels, the 3pcenter panel. The waits
after teleop_enable() that follow some of them stay.
The task mode follows what task runs, and nothing sets it any more:
task accepted EMC_TASK_SET_MODE and did nothing, and the Python, Tcl and
linuxcncrsh mode commands stopped sending it.

- NML: drop EMC_TASK_SET_MODE (type 504) and task's handling of it.
- shcom: drop sendManual(), sendAuto() and sendMdi(); schedrmt and
  emclcd no longer switch modes before MDI or opening a program, and
  emclcd's Test key no longer toggles the mode.
- halui: drop halui.mode.manual, .auto and .mdi. The .is-* status pins
  stay.
- Users of the pins: the xhc-hb04 pendant helper starts a program with
  halui.program.run only, the halui_pyvcp sim panel keeps the mode LEDs,
  the xhc-whb04b-6 example configuration and docs drop their mode nets,
  the remote start example needs halui.program.run only.
When the last MDI command finished, task reported DONE in the cycle
before the run ended, and again before motion was back in joint or
world mode. A client waiting for DONE could then see coordinated mode,
or have an axis jog refused: linuxcncrsh's test read TELEOP_ENABLE OFF
after its MDI commands on CI.

Task now reports DONE only when no run is on and motion is in the mode
the run went back to (with a 1 s timeout should motion not get there).

tests/task-modeless checks that motion is in world mode as soon as an
MDI command is DONE, and that a jog right after is accepted.
GStat gets is_jog_ok(), is_spindle_ok(), is_pause_jog_ok() and a
pause-jog-ok-changed signal. Jog and spindle action buttons use them,
STOP_JOG works while paused, and UPDATE_VAR_FILE saves the parameter
file with task_plan_synch() instead of a mode change.
Show the jog page while jogs during a pause are possible and restore
the previous page on resume or abort.
Don't switch to teleop while paused. Gscreen makes its mode and axis
buttons sensitive while paused and returns to the paused mode on resume.
Use STATUS.is_jog_ok() in kb_jog and only switch to manual mode when
not jogging during a pause.
… modes

The planner table has one idle situation instead of Manual, MDI and Auto
idle. stale-motion-status no longer waits for coordinated mode after
mode(AUTO), and jog-while-paused reads task.mode.is-manual.
In position is the planner's. The joints follow it through the cubic
interpolators and arrive a few cycles later. Since mode changes are
deferred instead of dropped, the change to joint mode happened on the
first in-position cycle and took pos_cmd mid-spline, so an MDI move from
joint mode ended up to 0.0003 mm off its target in about 1 run in 100.

Wait until the last four points of each joint's cubic are the same. A
moving external offset never rests, so it does not hold the change up.
The save was dropped by looking at task_paused, which a program that ends
normally leaves set: after stepping a program to its end, a paused MDI
command would have resumed with that program's coolant. taskRunEnd()
clears it, as on the modeless branches.
tests/task-planner and test_task_probe recorded what the planner did with
every command, to show that the refactoring of emcTaskPlan() changed
nothing. That work is done.
@grandixximo

Copy link
Copy Markdown
Contributor

I think this should be split now that the modeless work is in it:

  1. Standalone fixes: the gscreen crash (c9f8e95) and the joints at rest before joint mode (7913b1e). The latter happens on master too: a joint mode request sent during an MDI G0 leaves the joint short by up to 0.004 mm, every time, and your commit fixes it.
  2. The planner refactor and the dead NML commands (breaking-change for out-of-tree clients).
  3. halui's pins in task.
  4. Modeless task and jog while paused, with the pause coolant fix that builds on it. Removing EMC_TASK_SET_MODE and halui.mode.* reopens the modeless task, and jog-while-paused #4700 mode question and deserves its own PR.

Still open from my earlier list: pulse() 50 ms can miss a task cycle under load, the two hal tests could be one, wait_complete() during a HAL-started run, and a note that task.estop.activate is not a safety input.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants